home *** CD-ROM | disk | FTP | other *** search
/ The 640 MEG Shareware Studio 2 / The 640 Meg Shareware Studio CD-ROM Volume II (Data Express)(1993).ISO / clang / jcool01.zip / TIMER.C < prev    next >
C/C++ Source or Header  |  1992-08-24  |  5KB  |  191 lines
  1. //
  2. // Copyright (C) 1991 Texas Instruments Incorporated.
  3. //
  4. // Permission is granted to any individual or institution to use, copy, modify,
  5. // and distribute this software, provided that this complete copyright and
  6. // permission notice is maintained, intact, in all copies and supporting
  7. // documentation.
  8. //
  9. // Texas Instruments Incorporated provides this software "as is" without
  10. // express or implied warranty.
  11. //
  12. //
  13. // Created: BMK 07/14/89 -- Initial design and implementation
  14. // Updated: LGO 09/23/89 -- Conform to COOL coding style
  15. // Updated: AFM 12/31/89 -- OS/2 port
  16. // Updated: DLS 03/22/91 -- New lite version
  17. // Updated: JAM 08/12/92 -- added *sec_elapsed() funcs
  18. //
  19. // The CoolTimer class provides timing code  for performance evaluation.  This code
  20. // was originally written by Joe Rahmeh at UT Austin.
  21. //
  22. //  User time:
  23. //    time cpu spends in user mode on behalf of the program.
  24. //  System time:
  25. //    time cpu spends in system mode on behalf of the program.
  26. //  Real time:
  27. //    what you get from a stop watch timer.
  28. //
  29.  
  30. #include <cool/Timer.h>
  31.  
  32. inline static long micro_sec_elapsed(clock_t start) {
  33.  clock_t end = clock();
  34.  if (end==clock_t(-1))  /* Processor time not available on this system */
  35.    return 0;
  36.  return long(double(end-start)/CLK_TCK*1000000.0);
  37. }
  38.  
  39. inline static long milli_sec_elapsed(clock_t start) {
  40.  clock_t end = clock();
  41.  if (end==clock_t(-1))  /* Processor time not available on this system */
  42.    return 0;
  43.  return long(double(end-start)/CLK_TCK*1000.0);
  44. }
  45.  
  46. void CoolTimer::mark () {
  47. #if !defined (UNIXTIMER)
  48.  usage0 = clock();
  49. #else
  50.  getrusage(0, &usage0);
  51.  ftime(&real0);
  52. #endif
  53. }
  54.  
  55.  
  56. long CoolTimer::real () {
  57. #if !defined (UNIXTIMER)
  58.  return milli_sec_elapsed(usage0);
  59. #else
  60.  long s, ms;
  61.  timeb  real;        // current elapsed real time
  62.  
  63.  ftime(&real);
  64.  s  = real.time    - real0.time;
  65.  ms = real.millitm - real0.millitm;
  66.  if(ms < 0)
  67.    {ms += 1000;
  68.     s--;
  69.    }
  70.  return 1000*s + ms;
  71. #endif
  72. }
  73.  
  74.  
  75. long CoolTimer::user () {
  76. #if !defined (UNIXTIMER)
  77.  return milli_sec_elapsed(usage0);
  78. #else
  79.  register long dsec, dusec;
  80.  rusage usage;       // current rusage structure
  81.  
  82.  getrusage(0, &usage);
  83.  dsec  = usage.ru_utime.tv_sec  - usage0.ru_utime.tv_sec;
  84.  dusec = usage.ru_utime.tv_usec - usage0.ru_utime.tv_usec;
  85.  if(dusec < 0)
  86.    {dusec += 1000000;
  87.     dsec--;
  88.    }
  89.  return(dsec*1000 + dusec/1000);
  90. #endif
  91. }
  92.  
  93.  
  94. long CoolTimer::system () {
  95. #if !defined (UNIXTIMER)
  96.  return(0L);
  97. #else
  98.  register long dsec, dusec;
  99.  rusage usage;       // current rusage structure
  100.  
  101.  getrusage(0, &usage);
  102.  dsec  = usage.ru_stime.tv_sec  - usage0.ru_stime.tv_sec;
  103.  dusec = usage.ru_stime.tv_usec - usage0.ru_stime.tv_usec;
  104.  if(dusec < 0)
  105.    {dusec += 1000000;
  106.     dsec--;
  107.    }
  108.  return(dsec*1000 + dusec/1000);
  109. #endif
  110. }
  111.  
  112.  
  113. long CoolTimer::all () {
  114. #if !defined (UNIXTIMER)
  115.  return milli_sec_elapsed(usage0);
  116. #else
  117.  register long dsec, dusec;
  118.  rusage usage;       // current rusage structure
  119.  
  120.  getrusage(0, &usage);
  121.  dsec  = usage.ru_utime.tv_sec   + usage.ru_stime.tv_sec
  122.        - usage0.ru_utime.tv_sec  - usage0.ru_stime.tv_sec;
  123.  dusec = usage.ru_utime.tv_usec  + usage.ru_stime.tv_usec
  124.        - usage0.ru_utime.tv_usec - usage0.ru_stime.tv_usec;
  125.  if(dusec < 0)
  126.    {dusec += 1000000;
  127.     dsec--;
  128.    }
  129.  return(dsec*1000 + dusec/1000);
  130. #endif
  131. }
  132.  
  133.  
  134. long CoolTimer::user_usec () {
  135. #if !defined (UNIXTIMER)
  136.  return micro_sec_elapsed(usage0);
  137. #else
  138.  register long dsec, dusec;
  139.  rusage usage;       // current rusage structure
  140.  
  141.  getrusage(0, &usage);
  142.  dsec  = usage.ru_utime.tv_sec  - usage0.ru_utime.tv_sec;
  143.  dusec = usage.ru_utime.tv_usec - usage0.ru_utime.tv_usec;
  144.  if(dusec < 0)
  145.    {dusec += 1000000;
  146.     dsec--;
  147.    }
  148.  return(dsec*1000000 + dusec);
  149. #endif
  150. }
  151.  
  152.  
  153. long CoolTimer::system_usec () {
  154. #if !defined (UNIXTIMER)
  155.  return(0L);
  156. #else
  157.  register long dsec, dusec;
  158.  rusage usage;       // current rusage structure
  159.  
  160.  getrusage(0, &usage);
  161.  dsec  = usage.ru_stime.tv_sec  - usage0.ru_stime.tv_sec;
  162.  dusec = usage.ru_stime.tv_usec - usage0.ru_stime.tv_usec;
  163.  if(dusec < 0)
  164.    {dusec += 1000000;
  165.     dsec--;
  166.    }
  167.  return(dsec*1000000 + dusec);
  168. #endif
  169. }
  170.  
  171.  
  172. long CoolTimer::all_usec() {
  173. #if !defined (UNIXTIMER)
  174.  return micro_sec_elapsed(usage0);
  175. #else
  176.  register long dsec, dusec;
  177.  rusage usage;       // current rusage structure
  178.  
  179.  getrusage(0, &usage);
  180.  dsec  = usage.ru_utime.tv_sec   + usage.ru_stime.tv_sec
  181.        - usage0.ru_utime.tv_sec  - usage0.ru_stime.tv_sec;
  182.  dusec = usage.ru_utime.tv_usec  + usage.ru_stime.tv_usec
  183.        - usage0.ru_utime.tv_usec - usage0.ru_stime.tv_usec;
  184.  if(dusec < 0)
  185.    {dusec += 1000000;
  186.     dsec--;
  187.    }
  188.  return(dsec*1000000 + dusec);
  189. #endif
  190. }
  191.